* Returns the #GdkDisplay to which @device pertains.
*
* Returns: (transfer none): a #GdkDisplay. This memory is owned
- * by GTK+, and must not be freed or unreffed.
+ * by GTK, and must not be freed or unreffed.
**/
GdkDisplay *
gdk_device_get_display (GdkDevice *device)
* Indicates to the GUI environment that the application has
* finished loading, using a given identifier.
*
- * GTK+ will call this function automatically for #GtkWindow
+ * GTK will call this function automatically for #GtkWindow
* with custom startup-notification identifier unless
* gtk_window_set_auto_startup_notification() is called to
* disable that feature.
* @GDK_CROSSING_NORMAL: crossing because of pointer motion.
* @GDK_CROSSING_GRAB: crossing because a grab is activated.
* @GDK_CROSSING_UNGRAB: crossing because a grab is deactivated.
- * @GDK_CROSSING_GTK_GRAB: crossing because a GTK+ grab is activated.
- * @GDK_CROSSING_GTK_UNGRAB: crossing because a GTK+ grab is deactivated.
- * @GDK_CROSSING_STATE_CHANGED: crossing because a GTK+ widget changed
+ * @GDK_CROSSING_GTK_GRAB: crossing because a GTK grab is activated.
+ * @GDK_CROSSING_GTK_UNGRAB: crossing because a GTK grab is deactivated.
+ * @GDK_CROSSING_STATE_CHANGED: crossing because a GTK widget changed
* state (e.g. sensitivity).
* @GDK_CROSSING_TOUCH_BEGIN: crossing because a touch sequence has begun,
* this event is synthetic as the pointer might have not left the surface.
* @Short_description: Using Pango in GDK
* @Title: Pango Interaction
*
- * Pango is the text layout system used by GDK and GTK+. The functions
+ * Pango is the text layout system used by GDK and GTK. The functions
* and types in this section are used to obtain clip regions for
* #PangoLayouts, and to get #PangoContexts that can be used with
* GDK.
*
* Creating a #PangoLayout object is the first step in rendering text,
- * and requires getting a handle to a #PangoContext. For GTK+ programs,
+ * and requires getting a handle to a #PangoContext. For GTK programs,
* you’ll usually want to use gtk_widget_get_pango_context(), or
* gtk_widget_create_pango_layout(). Once you have a #PangoLayout,
* you can set the text and attributes of it with Pango functions like
[self setFrame:new_frame display:YES];
- /* Let the resizing be handled by GTK+. */
+ /* Let the resizing be handled by GTK. */
if (g_main_context_pending (NULL))
g_main_context_iteration (NULL, FALSE);
}
}
- /* Special-case shift-tab since GTK+ expects
+ /* Special-case shift-tab since GTK expects
* GDK_KEY_ISO_Left_Tab for that.
*/
if (found && p[j] == GDK_KEY_Tab && modifiers[j] == shiftKey)
app_id = g_get_prgname ();
if (app_id == NULL)
- app_id = "GTK+ Application";
+ app_id = "GTK Application";
gdk_wayland_surface_set_application_id (surface, app_id);
GdkWaylandSurface *tmp_impl;
/* Use the device that was used for the grab as the device for
- * the popup surface setup - so this relies on GTK+ taking the
+ * the popup surface setup - so this relies on GTK taking the
* grab before showing the popup surface.
*/
if (impl->grab_input_seat)
{
GdkWaylandSurface *impl = GDK_WAYLAND_SURFACE (surface);
- /* Don't map crazy temp that GTK+ uses for internal X11 shenanigans. */
+ /* Don't map crazy temp that GTK uses for internal X11 shenanigans. */
if (GDK_IS_DRAG_SURFACE (surface) && surface->x < 0 && surface->y < 0)
return FALSE;
*/
/*
-GTK+ has two clipboards - normal clipboard and primary clipboard
+GTK has two clipboards - normal clipboard and primary clipboard
Primary clipboard is only handled
-internally by GTK+ (it's not portable to Windows).
+internally by GTK (it's not portable to Windows).
("C:" means clipboard client (requestor), "S:" means clipboard server (provider))
("transmute" here means "change the format of some data"; this term is used here
which are completely unrelated)
For Clipboard:
-GTK+ calls one of the gdk_clipboard_set* () functions (either supplying
+GTK calls one of the gdk_clipboard_set* () functions (either supplying
its own content provider, or giving a GTyped data for which GDK will
create a content provider automatically).
That function associates the content provider with the clipboard and calls
The content provider has a callback, which will be invoked every time
the data from this provider is needed.
-GTK+ might also call gdk_clipboard_store_async(), which instructs
+GTK might also call gdk_clipboard_store_async(), which instructs
the backend to put the data into the OS clipboard manager (if
supported and available) so that it remains available for other
processes after the clipboard owner terminates.
-When something needs to be obtained from clipboard, GTK+ calls
+When something needs to be obtained from clipboard, GTK calls
C: gdk_clipboard_read_async () -> gdk_clipboard_read_internal (),
providing it with a string-array of mime/types, which is internally
converted into a GdkContentFormats object.
not try to close & reopen it, unless that is strictly necessary.
The clipboard is closed after each queue processing run.
-GTK+ calls one of the gdk_clipboard_set* () functions (either supplying
+GTK calls one of the gdk_clipboard_set* () functions (either supplying
its own content provider, or giving a GTyped data for which GDK will
create a content provider automatically).
That function associates the content provider with the clipboard and calls
The content provider has a callback, which will be invoked every time
the data from this provider is needed.
-GTK+ might also call gdk_clipboard_store_async(), which instructs
+GTK might also call gdk_clipboard_store_async(), which instructs
the W32 backend to put the data into the OS clipboard manager by
sending WM_RENDERALLFORMATS to itself and then handling it normally.
This map is separate from the one that maps supported GDK contentformats
to W32 formats for locally-claimed clipboards.
-When something needs to be obtained from clipboard, GTK+ calls
+When something needs to be obtained from clipboard, GTK calls
C: gdk_clipboard_read_async () -> gdk_clipboard_read_internal (),
providing it with a string-array of mime/types, which is internally
converted into a GdkContentFormats object.
texts (strings) or textures (GdkPixbufs) this way.
If data must be stored on the clipboard, because the application is quitting,
-GTK+ will call
+GTK will call
S: gdk_clipboard_store_async()
on all the clipboards it owns. This creates multiple write stream (one for each
format being stored), each backed by a HGLOBAL memory object. Once all memory
_gdk_atom_array_index (atoms, GDK_WIN32_ATOM_INDEX_JFIF) = g_intern_static_string ("JFIF");
_gdk_atom_array_index (atoms, GDK_WIN32_ATOM_INDEX_GIF) = g_intern_static_string ("GIF");
- /* These are a bit unusual. It's here to allow GTK+ applications
+ /* These are a bit unusual. It's here to allow GTK applications
* to actually support CF_DIB and Shell ID List clipboard formats on their own,
* instead of allowing GDK to use them internally for interoperability.
*/
win32_clipdrop->compatibility_w32formats = g_hash_table_new_full (NULL, NULL, NULL, (GDestroyNotify) g_array_unref);
- /* GTK+ actually has more text formats, but it's unlikely that we'd
+ /* GTK actually has more text formats, but it's unlikely that we'd
* get anything other than UTF8_STRING these days.
* GTKTEXTBUFFERCONTENTS format can potentially be converted to
* W32-compatible rich text format, but that's too complex to address right now.
*
* Adds an event filter to @window, allowing you to intercept messages
* before they reach GDK. This is a low-level operation and makes it
- * easy to break GDK and/or GTK+, so you have to know what you're
+ * easy to break GDK and/or GTK, so you have to know what you're
* doing.
**/
void
* the window.
*
* There's a mismatch between data types supported by W32 (W32 formats)
- * and by GTK+ (GDK contentformats).
+ * and by GTK (GDK contentformats).
* To account for it the data is transmuted back and forth. There are two
* main points of transmutation:
- * * GdkWin32HDATAOutputStream: transmutes GTK+ data to W32 data
- * * GdkWin32Drop: transmutes W32 data to GTK+ data
+ * * GdkWin32HDATAOutputStream: transmutes GTK data to W32 data
+ * * GdkWin32Drop: transmutes W32 data to GTK data
*
* There are also two points where data formats are considered:
* * When source drag context is created, it gets a list of GDK contentformats
* that it supports, these are matched to the W32 formats they
* correspond to (possibly with transmutation). New W32 formats for
- * GTK+-specific contentformats are also created here (see below).
+ * GTK-specific contentformats are also created here (see below).
* * When target drop context is created, it queries the IDataObject
* for the list of W32 formats it supports and matches these to
* corresponding GDK contentformats that it will be able to provide
* (possibly with transmutation) later. Missing GDK contentformats for
* W32-specific formats are also created here (see below).
*
- * W32 formats are integers (CLIPFORMAT), while GTK+ contentformats
+ * W32 formats are integers (CLIPFORMAT), while GTK contentformats
* are mime/type strings, and cannot be used interchangeably.
*
- * To accommodate advanced GTK+ applications the code allows them to
+ * To accommodate advanced GTK applications the code allows them to
* register drop targets that accept W32 data formats, and to register
* drag sources that provide W32 data formats. To do that they must
* register with the mime/type "application/x.windows.ZZZ", where
* If such contentformat is accepted/provided, GDK will not try to
* transmute it to/from something else. Otherwise GDK will do the following
* transmutation:
- * * If GTK+ application provides image/png, image/gif or image/jpeg,
+ * * If GTK application provides image/png, image/gif or image/jpeg,
* GDK will claim to also provide "PNG", "GIF" or "JFIF" respectively,
* and will pass these along verbatim.
- * * If GTK+ application provides any GdkPixbuf-compatible contentformat,
+ * * If GTK application provides any GdkPixbuf-compatible contentformat,
* GDK will also offer "PNG" and CF_DIB W32 formats.
- * * If GTK+ application provides text/plain;charset=utf8, GDK will also offer
+ * * If GTK application provides text/plain;charset=utf8, GDK will also offer
* CF_UNICODETEXT (UTF-16-encoded) and CF_TEXT (encoded with thread-
* and locale-dependent codepage), and will do the conversion when such
* data is requested.
- * * If GTK+ application accepts image/png, image/gif or image/jpeg,
+ * * If GTK application accepts image/png, image/gif or image/jpeg,
* GDK will claim to also accept "PNG", "GIF" or "JFIF" respectively,
* and will pass these along verbatim.
- * * If GTK+ application accepts image/bmp, GDK will
+ * * If GTK application accepts image/bmp, GDK will
* claim to accept CF_DIB W32 format, and will convert
* it, changing the header, when such data is provided.
- * * If GTK+ application accepts text/plain;charset=utf8, GDK will
+ * * If GTK application accepts text/plain;charset=utf8, GDK will
* claim to accept CF_UNICODETEXT and CF_TEXT, and will do
* the conversion when such data is provided.
- * * If GTK+ application accepts text/uri-list, GDK will
+ * * If GTK application accepts text/uri-list, GDK will
* claim to accept "Shell IDList Array", and will do the
* conversion when such data is provided.
*
* Currently the conversion from text/uri-list to "Shell IDList Array" is not
- * implemented, so it's not possible to drag & drop files from GTK+
- * applications to non-GTK+ applications the same way one can drag files
+ * implemented, so it's not possible to drag & drop files from GTK
+ * applications to non-GTK applications the same way one can drag files
* from Windows Explorer.
*
- * To increase inter-GTK compatibility, GDK will register GTK+-specific
+ * To increase inter-GTK compatibility, GDK will register GTK-specific
* formats by their mime/types, as-is (i.e "text/plain;charset=utf-8", for example).
- * That way two GTK+ applications can exchange data in their native formats
+ * That way two GTK applications can exchange data in their native formats
* (both well-known ones, such as text/plain;charset=utf8, and special,
* known only to specific applications). This will work just
* fine as long as both applications agree on what kind of data is stored
* If more flexibility is needed, register one format that has some
* internal indicators of the kind of data it contains, then write the application
* in such a way that it requests the data and inspects its header before deciding
- * whether to accept it or not. For details see GTK+ drag & drop documentation
+ * whether to accept it or not. For details see GTK drag & drop documentation
* on the "drag-motion" and "drag-data-received" signals.
*
* How managed DnD works:
/* Awful hack to recognize temp files corresponding to
* images dragged from Firefox... Open the file right here
* so that it is less likely that Firefox manages to delete
- * it before the GTK+-using app (typically GIMP) has opened
+ * it before the GTK-using app (typically GIMP) has opened
* it.
*
* Not compiled in for now, because it means images dragged
if (protocol == GDK_DRAG_PROTO_XDND && drag_x11->version == 0)
{
- /* This ugly hack is necessary since GTK+ doesn't know about
+ /* This ugly hack is necessary since GTK doesn't know about
* the XDND protocol version, and in particular doesn't know
* that gdk_drag_find_window() has the side-effect
* of setting drag_x11->version, and therefore sometimes call
* gdk_x11_drag_drag_motion() without a prior call to
* gdk_drag_find_window(). This happens, e.g.
- * when GTK+ is proxying DND events to embedded windows.
+ * when GTK is proxying DND events to embedded windows.
*/
if (proxy_xid)
{
case GDK_DRAG_PROTO_ROOTWIN:
{
GdkContentFormats *formats = gdk_drag_get_formats (drag);
- /* GTK+ traditionally has used application/x-rootwin-drop,
+ /* GTK traditionally has used application/x-rootwin-drop,
* but the XDND spec specifies x-rootwindow-drop.
*/
if (gdk_content_formats_contain_mime_type (formats, "application/x-rootwindow-drop") ||
* @surface: (type GdkX11Surface): a #GdkSurface
* @variant: the theme variant to export
*
- * GTK+ applications can request a dark theme variant. In order to
- * make other applications - namely window managers using GTK+ for
- * themeing - aware of this choice, GTK+ uses this function to
+ * GTK applications can request a dark theme variant. In order to
+ * make other applications - namely window managers using GTK for
+ * themeing - aware of this choice, GTK uses this function to
* export the requested theme variant as _GTK_THEME_VARIANT property
* on toplevel surfaces.
*
- * Note that this property is automatically updated by GTK+, so this
- * function should only be used by applications which do not use GTK+
+ * Note that this property is automatically updated by GTK, so this
+ * function should only be used by applications which do not use GTK
* to create toplevel surfaces.
*/
void
*
* Serializes the @node for later deserialization via
* gsk_render_node_deserialize(). No guarantees are made about the format
- * used other than that the same version of GTK+ will be able to deserialize
+ * used other than that the same version of GTK will be able to deserialize
* the result of a call to gsk_render_node_serialize() and
* gsk_render_node_deserialize() will correctly reject files it cannot open
- * that were created with previous versions of GTK+.
+ * that were created with previous versions of GTK.
*
* The intended use of this functions is testing, benchmarking and debugging.
* The format is not meant as a permanent storage format.
* GtkAssistantPage:complete:
*
* Setting the "complete" property to %TRUE marks a page as
- * complete (i.e.: all the required fields are filled out). GTK+ uses
+ * complete (i.e.: all the required fields are filled out). GTK uses
* this information to control the sensitivity of the navigation buttons.
*/
g_object_class_install_property (object_class,
*
* Forces @assistant to recompute the buttons state.
*
- * GTK+ automatically takes care of this in most situations,
+ * GTK automatically takes care of this in most situations,
* e.g. when the user goes to a different page, or when the
* visibility or completeness of a page changes.
*
* parsing custom tags and constructing child objects.
*
* The GtkBuildable interface is implemented by all widgets and
- * many of the non-widget objects that are provided by GTK+. The
+ * many of the non-widget objects that are provided by GTK. The
* main user of this interface is #GtkBuilder. There should be
* very little need for applications to call any of these functions directly.
*
* @GTK_BUILDER_ERROR_INVALID_VALUE: #GtkBuilder couldn’t parse
* some attribute value.
* @GTK_BUILDER_ERROR_VERSION_MISMATCH: The input file requires a newer version
- * of GTK+.
+ * of GTK.
* @GTK_BUILDER_ERROR_DUPLICATE_ID: An object id occurred twice.
* @GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED: A specified object type is of the same type or
* derived from the type of the composite class being extended with builder XML.
*
* As outlined in
* [GtkWidget’s geometry management section][geometry-management],
- * GTK+ uses a height-for-width
+ * GTK uses a height-for-width
* geometry management system to compute the sizes of widgets and user
* interfaces. #GtkCellArea uses the same semantics to calculate the
* size of an area for an arbitrary number of #GtkTreeModel rows.
* ]|
*
* Furthermore for implementations of GtkCellLayout that use a #GtkCellArea
- * to lay out cells (all GtkCellLayouts in GTK+ use a GtkCellArea)
+ * to lay out cells (all GtkCellLayouts in GTK use a GtkCellArea)
* [cell properties][cell-properties] can also be defined in the format by
* specifying the custom <cell-packing> attribute which can contain multiple
* <property> elements defined in the normal way.
* See gtk_cell_editable_start_editing() for information on the lifecycle of
* the @editable and a way to do setup that doesn’t depend on the @renderer.
*
- * Note that GTK+ doesn't guarantee that cell renderers will
+ * Note that GTK doesn't guarantee that cell renderers will
* continue to use the same kind of widget for editing in future
* releases, therefore you should check the type of @editable
* before doing any specific setup, as in the following example:
* #GtkCellRendererAccel displays a keyboard accelerator (i.e. a key
* combination like `Control + a`). If the cell renderer is editable,
* the accelerator can be changed by simply typing the new combination.
- *
- * The #GtkCellRendererAccel cell renderer was added in GTK+ 2.10.
*/
/**
* GtkCellRendererAccel:accel-mode:
*
- * Determines if the edited accelerators are GTK+ accelerators. If
+ * Determines if the edited accelerators are GTK accelerators. If
* they are, consumed modifiers are suppressed, only accelerators
- * accepted by GTK+ are allowed, and the accelerators are rendered
+ * accepted by GTK are allowed, and the accelerators are rendered
* in the same way as they are in menus.
*/
g_object_class_install_property (object_class,
/**
* GtkCellRendererAccelMode:
- * @GTK_CELL_RENDERER_ACCEL_MODE_GTK: GTK+ accelerators mode
+ * @GTK_CELL_RENDERER_ACCEL_MODE_GTK: GTK accelerators mode
* @GTK_CELL_RENDERER_ACCEL_MODE_OTHER: Other accelerator mode
*
- * Determines if the edited accelerators are GTK+ accelerators. If
+ * Determines if the edited accelerators are GTK accelerators. If
* they are, consumed modifiers are suppressed, only accelerators
- * accepted by GTK+ are allowed, and the accelerators are rendered
+ * accepted by GTK are allowed, and the accelerators are rendered
* in the same way as they are in menus.
*/
typedef enum
* box and sets it to display the column specified by its
* #GtkCellRendererCombo:text-column property. Further properties of the combo box
* can be set in a handler for the #GtkCellRenderer::editing-started signal.
- *
- * The #GtkCellRendererCombo cell renderer was added in GTK+ 2.6.
*/
typedef struct _GtkCellRendererComboPrivate GtkCellRendererComboPrivate;
*
* #GtkCellRendererProgress renders a numeric value as a progress par in a cell.
* Additionally, it can display a text on top of the progress bar.
- *
- * The #GtkCellRendererProgress cell renderer was added in GTK+ 2.6.
*/
* for choosing colors. Depending on the situation, colors may be
* allowed to have alpha (translucency).
*
- * In GTK+, the main widgets that implement this interface are
+ * In GTK, the main widgets that implement this interface are
* #GtkColorChooserWidget, #GtkColorChooserDialog and #GtkColorButton.
*/
* @device: a #GdkDevice
*
* Pops up the menu of @combo_box. Note that currently this does not do anything
- * with the device, as it was previously only used for list-mode ComboBoxes,
- * and those were removed in GTK+ 4. However, it is retained in case similar
+ * with the device, as it was previously only used for list-mode combo boxes,
+ * and those were removed in GTK 4. However, it is retained in case similar
* functionality is added back later.
**/
void
if (g_utf8_get_char (g_utf8_next_char (words[1])) > 0)
{
- g_warning ("GTK+ supports to output one char only: %s: %s", val, line);
+ g_warning ("GTK supports to output one char only: %s: %s", val, line);
goto fail;
}
* of input, e.g. to display a message, ask a question, or anything else
* that does not require extensive effort on the user’s part.
*
- * GTK+ treats a dialog as a window split vertically. The top section is a
+ * GTK treats a dialog as a window split vertically. The top section is a
* #GtkBox, and is where widgets such as a #GtkLabel or a #GtkEntry should
* be packed. The bottom area is known as the
* “action area”. This is generally used for
* If you add buttons to #GtkDialog using gtk_dialog_new_with_buttons(),
* gtk_dialog_add_button(), gtk_dialog_add_buttons(), or
* gtk_dialog_add_action_widget(), clicking the button will emit a signal
- * called #GtkDialog::response with a response ID that you specified. GTK+
+ * called #GtkDialog::response with a response ID that you specified. GTK
* will never assign a meaning to positive response IDs; these are entirely
* user-defined. But for convenience, you can use the response IDs in the
* #GtkResponseType enumeration (these all have values less than zero). If
* GtkResponseType:
* @GTK_RESPONSE_NONE: Returned if an action widget has no response id,
* or if the dialog gets programmatically hidden or destroyed
- * @GTK_RESPONSE_REJECT: Generic response id, not used by GTK+ dialogs
- * @GTK_RESPONSE_ACCEPT: Generic response id, not used by GTK+ dialogs
+ * @GTK_RESPONSE_REJECT: Generic response id, not used by GTK dialogs
+ * @GTK_RESPONSE_ACCEPT: Generic response id, not used by GTK dialogs
* @GTK_RESPONSE_DELETE_EVENT: Returned if the dialog is deleted
- * @GTK_RESPONSE_OK: Returned by OK buttons in GTK+ dialogs
- * @GTK_RESPONSE_CANCEL: Returned by Cancel buttons in GTK+ dialogs
- * @GTK_RESPONSE_CLOSE: Returned by Close buttons in GTK+ dialogs
- * @GTK_RESPONSE_YES: Returned by Yes buttons in GTK+ dialogs
- * @GTK_RESPONSE_NO: Returned by No buttons in GTK+ dialogs
- * @GTK_RESPONSE_APPLY: Returned by Apply buttons in GTK+ dialogs
- * @GTK_RESPONSE_HELP: Returned by Help buttons in GTK+ dialogs
+ * @GTK_RESPONSE_OK: Returned by OK buttons in GTK dialogs
+ * @GTK_RESPONSE_CANCEL: Returned by Cancel buttons in GTK dialogs
+ * @GTK_RESPONSE_CLOSE: Returned by Close buttons in GTK dialogs
+ * @GTK_RESPONSE_YES: Returned by Yes buttons in GTK dialogs
+ * @GTK_RESPONSE_NO: Returned by No buttons in GTK dialogs
+ * @GTK_RESPONSE_APPLY: Returned by Apply buttons in GTK dialogs
+ * @GTK_RESPONSE_HELP: Returned by Help buttons in GTK dialogs
*
* Predefined values for use as response ids in gtk_dialog_add_button().
- * All predefined values are negative; GTK+ leaves values of 0 or greater for
+ * All predefined values are negative; GTK leaves values of 0 or greater for
* application-defined response ids.
*/
typedef enum
* When using an entry for passwords and other sensitive information,
* it can be put into “password mode” using gtk_entry_set_visibility().
* In this mode, entered text is displayed using a “invisible” character.
- * By default, GTK+ picks the best invisible character that is available
+ * By default, GTK picks the best invisible character that is available
* in the current font, but it can be changed with
* gtk_entry_set_invisible_char().
*
*
* Whether the primary icon is activatable.
*
- * GTK+ emits the #GtkEntry::icon-press and #GtkEntry::icon-release
+ * GTK emits the #GtkEntry::icon-press and #GtkEntry::icon-release
* signals only on sensitive, activatable icons.
*
* Sensitive, but non-activatable icons can be used for purely
*
* Whether the secondary icon is activatable.
*
- * GTK+ emits the #GtkEntry::icon-press and #GtkEntry::icon-release
+ * GTK emits the #GtkEntry::icon-press and #GtkEntry::icon-release
* signals only on sensitive, activatable icons.
*
* Sensitive, but non-activatable icons can be used for purely
*
* Whether the primary icon is sensitive.
*
- * An insensitive icon appears grayed out. GTK+ does not emit the
+ * An insensitive icon appears grayed out. GTK does not emit the
* #GtkEntry::icon-press and #GtkEntry::icon-release signals and
* does not allow DND from insensitive icons.
*
*
* Whether the secondary icon is sensitive.
*
- * An insensitive icon appears grayed out. GTK+ does not emit the
+ * An insensitive icon appears grayed out. GTK does not emit the
* #GtkEntry::icon-press and #GtkEntry::icon-release signals and
* does not allow DND from insensitive icons.
*
* as the invisible char, and will also appear that way when
* the text in the entry widget is copied elsewhere.
*
- * By default, GTK+ picks the best invisible character available
+ * By default, GTK picks the best invisible character available
* in the current font, but it can be changed with
* gtk_entry_set_invisible_char().
*
* Sets the character to use in place of the actual text when
* gtk_entry_set_visibility() has been called to set text visibility
* to %FALSE. i.e. this is the character used in “password mode” to
- * show the user how many characters have been typed. By default, GTK+
+ * show the user how many characters have been typed. By default, GTK
* picks the best invisible char available in the current font. If you
* set the invisible char to 0, then the user will get no feedback
* at all; there will be no text on the screen as they type.
/**
* SECTION:gtkenums
- * @Short_description: Public enumerated types used throughout GTK+
+ * @Short_description: Public enumerated types used throughout GTK
* @Title: Standard Enumerations
*/
* @GTK_SENSITIVITY_ON: The arrow is always sensitive
* @GTK_SENSITIVITY_OFF: The arrow is always insensitive
*
- * Determines how GTK+ handles the sensitivity of stepper arrows
+ * Determines how GTK handles the sensitivity of stepper arrows
* at the end of range widgets.
*/
typedef enum
* @See_also: #GtkFileChooserDialog, #GtkFileChooserWidget, #GtkFileChooserButton
*
* #GtkFileChooser is an interface that can be implemented by file
- * selection widgets. In GTK+, the main objects that implement this
+ * selection widgets. In GTK, the main objects that implement this
* interface are #GtkFileChooserWidget, #GtkFileChooserDialog, and
* #GtkFileChooserButton. You do not need to write an object that
* implements the #GtkFileChooser interface unless you are trying to
/* -*- Mode: C; c-file-style: "gnu"; tab-width: 8 -*- */
-/* GTK+: gtkfilechooserbutton.c
+/* gtkfilechooserbutton.c
*
* Copyright (c) 2004 James M. Cape <jcape@ignore-your.tv>
*
-/* GTK+: gtkfilechooserbutton.h
+/* gtkfilechooserbutton.h
*
* Copyright (c) 2004 James M. Cape <jcape@ignore-your.tv>
*
impl->auto_selecting_first_row = FALSE;
impl->renamed_file = NULL;
- /* Ensure GTK+ private types used by the template
+ /* Ensure private types used by the template
* definition before calling gtk_widget_init_template()
*/
g_type_ensure (GTK_TYPE_PATH_BAR);
*
* Also see #GtkListBox.
*
- * GtkFlowBox was added in GTK+ 3.12.
- *
* # CSS nodes
*
* |[<!-- language="plain" -->
* @See_also: #GtkFontChooserDialog, #GtkFontChooserWidget, #GtkFontButton
*
* #GtkFontChooser is an interface that can be implemented by widgets
- * displaying the list of fonts. In GTK+, the main objects
+ * displaying the list of fonts. In GTK, the main objects
* that implement this interface are #GtkFontChooserWidget,
- * #GtkFontChooserDialog and #GtkFontButton. The GtkFontChooser interface
- * has been introduced in GTK+ 3.2.
+ * #GtkFontChooserDialog and #GtkFontButton.
*/
enum
* gtk_font_chooser_set_font_map (font_chooser, fontmap);
* ]|
*
- * Note that other GTK+ widgets will only be able to use the application-specific
+ * Note that other GTK widgets will only be able to use the application-specific
* font if it is present in the font map they use:
*
* |[
* by @gesture.
*
* Returns: (transfer container) (element-type GdkEventSequence): A list
- * of #GdkEventSequences, the list elements are owned by GTK+
+ * of #GdkEventSequences, the list elements are owned by GTK
* and must not be freed or modified, the list itself must be deleted
* through g_list_free()
**/
* #GtkGestureClick is a #GtkGesture implementation able to recognize
* multiple clicks on a nearby zone, which can be listened for through
* the #GtkGestureClick::pressed signal. Whenever time or distance
- * between clicks exceed the GTK+ defaults, #GtkGestureClick::stopped
+ * between clicks exceed the GTK defaults, #GtkGestureClick::stopped
* is emitted, and the click counter is reset.
*/
* @y: the Y coordinate where the press happened, relative to the widget allocation
*
* This signal is emitted whenever a press goes unmoved/unreleased longer than
- * what the GTK+ defaults tell.
+ * what the GTK defaults tell.
*/
signals[PRESSED] =
g_signal_new (I_("pressed"),
* @backlog: (out) (array length=n_elems): coordinates and times for the backlog events
* @n_elems: (out): return location for the number of elements
*
- * By default, GTK+ will limit rate of input events. On stylus input where
+ * By default, GTK will limit rate of input events. On stylus input where
* accuracy of strokes is paramount, this function returns the accumulated
* coordinate/timing state before the emission of the current
* #GtkGestureStylus::motion signal.
* GtkIconTheme::changed:
* @self: the icon theme
*
- * Emitted when the current icon theme is switched or GTK+ detects
+ * Emitted when the current icon theme is switched or GTK detects
* that a change has occurred in the contents of the current
* icon theme.
*/
"g_signal_stop_emission_by_name() in your signal handler to prevent "
"the default handler from running. Look at the source code "
"for the default handler in gtkiconview.c to get an idea what "
- "your handler should do. (gtkiconview.c is in the GTK+ source "
- "code.) If you're using GTK+ from a language other than C, "
+ "your handler should do. (gtkiconview.c is in the GTK source "
+ "code.) If you're using GTK from a language other than C, "
"there may be a more natural way to override default handlers, e.g. via derivation.",
signal, g_type_name (required_iface), signal);
return FALSE;
/**
* GtkImageType:
* @GTK_IMAGE_EMPTY: there is no image displayed by the widget
- * @GTK_IMAGE_ICON_NAME: the widget contains a named icon.
- * This image type was added in GTK+ 2.6
- * @GTK_IMAGE_GICON: the widget contains a #GIcon.
- * This image type was added in GTK+ 2.14
- * @GTK_IMAGE_PAINTABLE: the widget contains a #GdkPaintable.
- * This image type was added in GTK+ 3.96
+ * @GTK_IMAGE_ICON_NAME: the widget contains a named icon
+ * @GTK_IMAGE_GICON: the widget contains a #GIcon
+ * @GTK_IMAGE_PAINTABLE: the widget contains a #GdkPaintable
*
* Describes the image data representation used by a #GtkImage. If you
* want to get the image from the widget, you can only get the
* @short_description: Base class for input method contexts
* @include: gtk/gtk.h,gtk/gtkimmodule.h
*
- * #GtkIMContext defines the interface for GTK+ input methods. An input method
- * is used by GTK+ text input widgets like #GtkEntry to map from key events to
+ * #GtkIMContext defines the interface for GTK input methods. An input method
+ * is used by GTK text input widgets like #GtkEntry to map from key events to
* Unicode character strings.
*
* The default input method can be set programmatically via the
* #GtkSettings:gtk-im-module GtkSettings property. Alternatively, you may set
* the GTK_IM_MODULE environment variable as documented in
- * [Running GTK+ Applications][gtk-running].
+ * [Running GTK Applications][gtk-running].
*
* The #GtkEntry #GtkEntry:im-module and #GtkTextView #GtkTextView:im-module
* properties may also be used to set input methods for specific widget
* An input method may consume multiple key events in sequence and finally
* output the composed result. This is called preediting, and an input method
* may provide feedback about this process by displaying the intermediate
- * composition states as preedit text. For instance, the default GTK+ input
+ * composition states as preedit text. For instance, the default GTK input
* method implements the input of arbitrary Unicode code points by holding down
* the Control and Shift keys and then typing “U” followed by the hexadecimal
* digits of the code point. When releasing the Control and Shift keys,
* preediting ends and the character is inserted as text. Ctrl+Shift+u20AC for
* example results in the € sign.
*
- * Additional input methods can be made available for use by GTK+ widgets as
+ * Additional input methods can be made available for use by GTK widgets as
* loadable modules. An input method module is a small shared library which
* implements a subclass of #GtkIMContext or #GtkIMContextSimple and exports
* these four functions:
* After a new loadable input method module has been installed on the system,
* the configuration file `gtk.immodules` needs to be
* regenerated by [gtk-query-immodules-3.0][gtk-query-immodules-3.0],
- * in order for the new input method to become available to GTK+ applications.
+ * in order for the new input method to become available to GTK applications.
*/
enum {
GtkIMContextQuartz *qc = GTK_IM_CONTEXT_QUARTZ (context);
qc->focused = FALSE;
- /* Commit any partially built strings or it'll mess up other GTK+ widgets in the window */
+ /* Commit any partially built strings or it'll mess up other widgets in the window */
discard_preedit (context);
}
/*
* gtkinfobar.c
- * This file is part of GTK+
+ * This file is part of GTK
*
* Copyright (C) 2005 - Paolo Maggi
*
*
* Similar to #GtkMessageDialog, the contents of a #GtkInfoBar can by
* classified as error message, warning, informational message, etc,
- * by using gtk_info_bar_set_message_type(). GTK+ may use the message type
+ * by using gtk_info_bar_set_message_type(). GTK may use the message type
* to determine how the message is displayed.
*
* A simple example for using a #GtkInfoBar:
*
* Sets the message type of the message area.
*
- * GTK+ uses this type to determine how the message is displayed.
+ * GTK uses this type to determine how the message is displayed.
*/
void
gtk_info_bar_set_message_type (GtkInfoBar *info_bar,
/*
* gtkinfobar.h
- * This file is part of GTK+
+ * This file is part of GTK
*
* Copyright (C) 2005 - Paolo Maggi
*
*
* # Links
*
- * GTK+ supports markup for clickable hyperlinks in addition
+ * GTK supports markup for clickable hyperlinks in addition
* to regular Pango markup. The markup for links is borrowed from HTML,
- * using the `<a>` with “href“, “title“ and “class“ attributes. GTK+ renders links
+ * using the `<a>` with “href“, “title“ and “class“ attributes. GTK renders links
* similar to the way they appear in web browsers, with colored, underlined
* text. The “title“ attribute is displayed as a tooltip on the link. The “class“
* attribute is used as style class on the CSS node for the link.
* const char *text =
* "Go to the"
* "<a href=\"http://www.gtk.org title=\"<i>Our</i> website\">"
- * "GTK+ website</a> for more...";
+ * "GTK website</a> for more...";
* GtkWidget *label = gtk_label_new (NULL);
* gtk_label_set_markup (GTK_LABEL (label), text);
* ]|
* by the edge of the widget if it exceeds the widget size.
*
* Note that setting line wrapping to %TRUE does not make the label
- * wrap at its parent container’s width, because GTK+ widgets
+ * wrap at its parent container’s width, because GTK widgets
* conceptually can’t make their requisition depend on the parent
* container’s size. For a label that wraps at a specific position,
* set the label’s width using gtk_widget_set_size_request().
* or for use in a #GtkWidget::query-tooltip handler.
*
* Returns: (nullable): the currently active URI or %NULL if there is none.
- * The string is owned by GTK+ and must not be freed or modified.
+ * The string is owned by GTK and must not be freed or modified.
*/
const char *
gtk_label_get_current_uri (GtkLabel *self)
* values 0.25, 0.75 and 1.0 respectively.
*
* Note that it is your responsibility to update preexisting offsets
- * when changing the minimum or maximum value. GTK+ will simply clamp
+ * when changing the minimum or maximum value. GTK will simply clamp
* them to the new range.
*
* ## Adding a custom offset on the bar
* set the minimum value to 0 and the maximum value to 5 after changing the indicator
* mode to discrete.
*
- * GtkLevelBar was introduced in GTK+ 3.6.
- *
* # GtkLevelBar as GtkBuildable
*
* The GtkLevelBar implementation of the GtkBuildable interface supports a
* the user tries to activate it. If it is selectable, the row will be marked
* as selected when the user tries to select it.
*
- * The GtkListBox widget was added in GTK+ 3.10.
- *
* # GtkListBox as GtkBuildable
*
* The GtkListBox implementation of the #GtkBuildable interface supports
*
* # Performance Considerations
*
- * Internally, the #GtkListStore was implemented with a linked list with
- * a tail pointer prior to GTK+ 2.6. As a result, it was fast at data
- * insertion and deletion, and not fast at random data access. The
- * #GtkListStore sets the #GTK_TREE_MODEL_ITERS_PERSIST flag, which means
- * that #GtkTreeIters can be cached while the row exists. Thus, if
- * access to a particular row is needed often and your code is expected to
- * run on older versions of GTK+, it is worth keeping the iter around.
+ * Internally, the #GtkListStore was originally implemented with a linked list
+ * with a tail pointer. As a result, it was fast at data insertion and deletion,
+ * and not fast at random data access. The #GtkListStore sets the
+ * #GTK_TREE_MODEL_ITERS_PERSIST flag, which means that #GtkTreeIters can be
+ * cached while the row exists. Thus, if access to a particular row is needed
+ * often and your code is expected to run on older versions of GTK, it is worth
+ * keeping the iter around.
*
* # Atomic Operations
*
*
* This provides a simple way to play back video files with GTK.
*
- * GTK+ provides a GIO extension point for #GtkMediaFile implementations
+ * GTK provides a GIO extension point for #GtkMediaFile implementations
* to allow for external implementations using various media frameworks.
- * GTK+ itself includes implementations using GStreamer and ffmpeg.
+ * GTK itself includes implementations using GStreamer and ffmpeg.
*/
typedef struct _GtkMediaFilePrivate GtkMediaFilePrivate;
* be changed to an arrow if it was customized.
*
* If the does not fit in the available space in the given direction,
- * GTK+ will its best to keep it inside the screen and fully visible.
+ * GTK will its best to keep it inside the screen and fully visible.
*
* If you pass %GTK_ARROW_NONE for a @direction, the popup will behave
* as if you passed %GTK_ARROW_DOWN (although you won’t see any arrows).
* allowed to change, so listen to the notify signals to update your item's
* appearance. When using a GObject library, this can conveniently be done
* with g_object_bind_property() and #GBinding, and this is how this is
- * implemented in GTK+; the appearance side is implemented in #GtkModelMenuItem.
+ * implemented in GTK; the appearance side is implemented in #GtkModelMenuItem.
*
* When an item is clicked, simply call gtk_menu_tracker_item_activated() in
* response. The #GtkMenuTrackerItem will take care of everything related to
* @short_description: Functions for working with GIO
* @Title: Filesystem utilities
*
- * The functions and objects described here make working with GTK+ and
+ * The functions and objects described here make working with GTK and
* GIO more convenient.
*
* #GtkMountOperation is needed when mounting volumes:
* oriented horizontally or vertically. #GtkOrientable is more flexible in that
* it allows the orientation to be changed at runtime, allowing the widgets
* to “flip”.
- *
- * #GtkOrientable was introduced in GTK+ 2.16.
*/
* page_setup = new_page_setup;
* }
* ]|
- *
- * Printing support was added in GTK+ 2.10.
*/
#define KEYFILE_GROUP_NAME "Page Setup"
* The #GtkPaperSize object stores not only the dimensions (width
* and height) of a paper size and its name, it also provides
* default [print margins][print-margins].
- *
- * Printing support has been added in GTK 2.10.
*/
* g_object_unref (layout);
* }
* ]|
- *
- * Printing support was added in GTK+ 2.10.
*/
*
* This function is intended to be used when implementing
* an internal print preview, it is not needed for printing,
- * since GTK+ itself creates a suitable cairo context in that
+ * since GTK itself creates a suitable cairo context in that
* case.
*/
void
* such as its description, its location, the number of queued jobs,
* etc. Most importantly, a #GtkPrinter object can be used to create
* a #GtkPrintJob object, which lets you print to the printer.
- *
- * Printing support was added in GTK+ 2.10.
*/
* @See_also: #GtkPrintContext, #GtkPrintUnixDialog
*
* GtkPrintOperation is the high-level, portable printing API.
- * It looks a bit different than other GTK+ dialogs such as the
+ * It looks a bit different than other GTK dialogs such as the
* #GtkFileChooser, since some platforms don’t expose enough
* infrastructure to implement a good print dialog. On such
* platforms, GtkPrintOperation uses the native print dialog.
- * On platforms which do not provide a native print dialog, GTK+
+ * On platforms which do not provide a native print dialog, GTK
* uses its own, see #GtkPrintUnixDialog.
*
* The typical way to use the high-level printing API is to create
* A string used to identify the job (e.g. in monitoring
* applications like eggcups).
*
- * If you don't set a job name, GTK+ picks a default one
+ * If you don't set a job name, GTK picks a default one
* by numbering successive print jobs.
*/
g_object_class_install_property (gobject_class,
* Used as the label of the tab containing custom widgets.
* Note that this property may be ignored on some platforms.
*
- * If this is %NULL, GTK+ uses a default label.
+ * If this is %NULL, GTK uses a default label.
*/
g_object_class_install_property (gobject_class,
PROP_CUSTOM_TAB_LABEL,
* Sets the name of the print job. The name is used to identify
* the job (e.g. in monitoring applications like eggcups).
*
- * If you don’t set a job name, GTK+ picks a default one by
+ * If you don’t set a job name, GTK picks a default one by
* numbering successive print jobs.
**/
void
* or paper size from a key file.
*
* Error codes that identify various errors that can occur while
- * using the GTK+ printing support.
+ * using the GTK printing support.
*/
typedef enum
{
* the settings for the next time your app runs, or even store them in a
* document. The predefined keys try to use shared values as much as possible
* so that moving such a document between systems still works.
- *
- * Printing support was added in GTK+ 2.10.
*/
typedef struct _GtkPrintSettingsClass GtkPrintSettingsClass;
* GTK_PRINT_SETTINGS_OUTPUT_URI:
*
* The key used by the “Print to file” printer to store the URI
- * to which the output should be written. GTK+ itself supports
+ * to which the output should be written. GTK itself supports
* only “file://” URIs.
*/
#define GTK_PRINT_SETTINGS_OUTPUT_URI "output-uri"
* type of scroll event that occurred and the resultant new value.
* The application can handle the event itself and return %TRUE to
* prevent further processing. Or, by returning %FALSE, it can pass
- * the event to other handlers until the default GTK+ handler is
+ * the event to other handlers until the default GTK handler is
* reached.
*
* The value parameter is unrounded. An application that overrides
* the GtkRange::change-value signal is responsible for clamping the
- * value to the desired number of decimal digits; the default GTK+
+ * value to the desired number of decimal digits; the default GTK
* handler clamps the value based on #GtkRange:round-digits.
*
* Returns: %TRUE to prevent other handlers from being invoked for
{
GtkRangePrivate *priv = gtk_range_get_instance_private (range);
- /* Don't perform any GDK/GTK+ grab here. Since a button
+ /* Don't perform any GDK/GTK grab here. Since a button
* is down, there's an ongoing implicit grab on
* the widget, which pretty much guarantees this
* is the only widget receiving the pointer events.
*
* The #GtkRecentManager acts like a database of all the recently
* used files. You can create new #GtkRecentManager objects, but
- * it is more efficient to use the default manager created by GTK+.
+ * it is more efficient to use the default manager created by GTK
*
* Adding a new recently used file is as simple as:
*
* Note that the maximum age of the recently used files list is
* controllable through the #GtkSettings:gtk-recent-files-max-age
* property.
- *
- * Recently used files are supported since GTK+ 2.10.
*/
#include "config.h"
* When styling #GtkRevealer using CSS, remember that it only hides its contents,
* not itself. That means applied margin, padding and borders will be
* visible even when the #GtkRevealer:reveal-child property is set to %FALSE.
- *
- * The GtkRevealer widget was added in GTK+ 3.10.
*/
/**
* Adds a mark at @value.
*
* A mark is indicated visually by drawing a tick mark next to the scale,
- * and GTK+ makes it easy for the user to position the scale exactly at the
+ * and GTK makes it easy for the user to position the scale exactly at the
* marks value.
*
* If @markup is not %NULL, text is shown next to the tick mark.
*
* #GtkScaleButton provides a button which pops up a scale widget.
* This kind of widget is commonly used for volume controls in multimedia
- * applications, and GTK+ provides a #GtkVolumeButton subclass that
+ * applications, and GTK provides a #GtkVolumeButton subclass that
* is tailored for this use case.
*
* # CSS nodes
*
* The orientation of the #GtkScaleButton's popup window.
*
- * Note that since GTK+ 2.16, #GtkScaleButton implements the
- * #GtkOrientable interface which has its own @orientation
- * property. However we redefine the property here in order to
- * override its default horizontal orientation.
+ * Note that #GtkScaleButton implements the #GtkOrientable interface
+ * which has its own @orientation property. However, we redefine the
+ * property here in order to override its default horizontal orientation.
**/
g_object_class_override_property (gobject_class,
PROP_ORIENTATION,
*
* Returns the size of a non-scrolling border around the
* outside of the scrollable. An example for this would
- * be treeview headers. GTK+ can use this information to
+ * be treeview headers. GTK can use this information to
* display overlaid graphics, like the overshoot indication,
* at the right position.
*
g_type_class_unref (class);
}
- /* This is just a hack for compatibility with GTK+-1.2 where a string
+ /* This is just a hack for compatibility with GTK 1.2 where a string
* could be used for a single flag value / without the support for multiple
* values in gtk_rc_parse_flags(), this isn't very useful.
*/
*
* The size group for the accelerator portion of shortcuts in this group.
*
- * This is used internally by GTK+, and must not be modified by applications.
+ * This is used internally by GTK, and must not be modified by applications.
*/
properties[PROP_ACCEL_SIZE_GROUP] =
g_param_spec_object ("accel-size-group",
*
* The size group for the textual portion of shortcuts in this group.
*
- * This is used internally by GTK+, and must not be modified by applications.
+ * This is used internally by GTK, and must not be modified by applications.
*/
properties[PROP_TITLE_SIZE_GROUP] =
g_param_spec_object ("title-size-group",
*
* A rough measure for the number of lines in this group.
*
- * This is used internally by GTK+, and is not useful for applications.
+ * This is used internally by GTK, and is not useful for applications.
*/
properties[PROP_HEIGHT] =
g_param_spec_uint ("height", P_("Height"), P_("Height"),
*
* An icon to represent the shortcut or gesture. This property is used if
* #GtkShortcutsShortcut:shortcut-type is set to #GTK_SHORTCUT_GESTURE.
- * For the other predefined gesture types, GTK+ provides an icon on its own.
+ * For the other predefined gesture types, GTK provides an icon on its own.
*/
properties[PROP_ICON] =
g_param_spec_object ("icon",
*
* This is typically used for gestures and should be a short, one-line
* text that describes the gesture itself. For the predefined gesture
- * types, GTK+ provides a subtitle on its own.
+ * types, GTK provides a subtitle on its own.
*/
properties[PROP_SUBTITLE] =
g_param_spec_string ("subtitle",
*
* The size group for the accelerator portion of this shortcut.
*
- * This is used internally by GTK+, and must not be modified by applications.
+ * This is used internally by GTK, and must not be modified by applications.
*/
properties[PROP_ACCEL_SIZE_GROUP] =
g_param_spec_object ("accel-size-group",
*
* The size group for the textual portion of this shortcut.
*
- * This is used internally by GTK+, and must not be modified by applications.
+ * This is used internally by GTK, and must not be modified by applications.
*/
properties[PROP_TITLE_SIZE_GROUP] =
g_param_spec_object ("title-size-group",
* GtkShortcutsShortcut:action-name:
*
* A detailed action name. If this is set for a shortcut
- * of type %GTK_SHORTCUT_ACCELERATOR, then GTK+ will use
+ * of type %GTK_SHORTCUT_ACCELERATOR, then GTK will use
* the accelerators that are associated with the action
* via gtk_application_set_accels_for_action(), and setting
* #GtkShortcutsShortcut:accelerator is not necessary.
* group; when all widgets have been removed, the size group will be
* freed.
*
- * Widgets can be part of multiple size groups; GTK+ will compute the
+ * Widgets can be part of multiple size groups; GTK will compute the
* horizontal size of a widget from the horizontal requisition of all
* widgets that can be reached from the widget by a chain of size groups
* of type %GTK_SIZE_GROUP_HORIZONTAL or %GTK_SIZE_GROUP_BOTH, and the
* Returns the list of widgets associated with @size_group.
*
* Returns: (element-type GtkWidget) (transfer none): a #GSList of
- * widgets. The list is owned by GTK+ and should not be modified.
+ * widgets. The list is owned by GTK and should not be modified.
**/
GSList *
gtk_size_group_get_widgets (GtkSizeGroup *size_group)
/* looks for a cached size request for this for_size.
*
* Note that this caching code was originally derived from
- * the Clutter toolkit but has evolved for other GTK+ requirements.
+ * the Clutter toolkit but has evolved for other GTK requirements.
*/
gboolean
_gtk_size_request_cache_lookup (const SizeRequestCache *cache,
/* GTK - The GIMP Toolkit
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
- * GtkSpinButton widget for GTK+
+ * GtkSpinButton widget for GTK
* Copyright (C) 1998 Lars Hamann and Stefan Jeske
*
* This library is free software; you can redistribute it and/or
* It is possible to associate multiple #GtkStackSwitcher widgets
* with the same #GtkStack widget.
*
- * The GtkStackSwitcher widget was added in 3.10.
- *
* # CSS nodes
*
* GtkStackSwitcher has a single CSS node named stackswitcher and
* gtk_style_context_add_provider_for_display(). The resulting style is a
* combination of all providers’ information in priority order.
*
- * For GTK+ widgets, any #GtkStyleContext returned by
+ * For GTK widgets, any #GtkStyleContext returned by
* gtk_widget_get_style_context() will already have a #GdkDisplay and
* RTL/LTR information set. The style context will also be updated
* automatically if any of these settings change on the widget.
* which style classes it uses itself, and which style classes may be added by
* applications to affect their appearance.
*
- * GTK+ defines macros for a number of style classes.
+ * GTK defines macros for a number of style classes.
*
* # Custom styling in UI libraries and applications
*
* Adds a global style provider to @display, which will be used
* in style construction for all #GtkStyleContexts under @display.
*
- * GTK+ uses this to make styling information from #GtkSettings
+ * GTK uses this to make styling information from #GtkSettings
* available.
*
* Note: If both priorities are the same, A #GtkStyleProvider
* information may be included.
*
* This function is intended for testing and debugging of the
- * CSS implementation in GTK+. There are no guarantees about
+ * CSS implementation in GTK. There are no guarantees about
* the format of the returned string, it may change.
*
* Returns: a newly allocated string representing @context
/**
* SECTION:gtktesting
- * @Short_description: Utilities for testing GTK+ applications
+ * @Short_description: Utilities for testing GTK applications
* @Title: Testing
*/
* stripped before return.
* @...: currently unused
*
- * This function is used to initialize a GTK+ test program.
+ * This function is used to initialize a GTK test program.
*
* It will in turn call g_test_init() and gtk_init() to properly
* initialize the testing framework and graphical toolkit. It’ll
*
* Using #GtkTextAttributes directly should rarely be necessary.
* It’s primarily useful with gtk_text_iter_get_attributes().
- * As with most GTK+ structs, the fields in this struct should only
+ * As with most GTK structs, the fields in this struct should only
* be read, never modified directly.
*/
struct _GtkTextAttributes
* image, or you want the tooltip to have different contents per #GtkTreeView
* row or cell, you will have to do a little more work:
*
- * - Set the #GtkWidget:has-tooltip property to %TRUE, this will make GTK+
+ * - Set the #GtkWidget:has-tooltip property to %TRUE, this will make GTK
* monitor the widget for motion and related events which are needed to
* determine when and where to show a tooltip.
*
* @Short_description: Interfaces for drag-and-drop support in GtkTreeView
* @Title: GtkTreeView drag-and-drop
*
- * GTK+ supports Drag-and-Drop in tree views with a high-level and a low-level
+ * GTK supports Drag-and-Drop in tree views with a high-level and a low-level
* API.
*
- * The low-level API consists of the GTK+ DND API, augmented by some treeview
+ * The low-level API consists of the GTK DND API, augmented by some treeview
* utility functions: gtk_tree_view_set_drag_dest_row(),
* gtk_tree_view_get_drag_dest_row(), gtk_tree_view_get_dest_row_at_pos(),
* gtk_tree_view_create_row_drag_icon(), gtk_tree_set_row_drag_data() and
*
* These functions must be called exactly once per proxy when the
* corresponding signal on the model is emitted. This single call
- * updates all row references for that proxy. Since built-in GTK+
+ * updates all row references for that proxy. Since built-in GTK
* objects like #GtkTreeView already use this mechanism internally,
* using them as the proxy object will produce unpredictable results.
* Further more, passing the same object as @model and @proxy
* “fixed-width” property is not clamped. If the column sizing is
* #GTK_TREE_VIEW_COLUMN_GROW_ONLY or #GTK_TREE_VIEW_COLUMN_AUTOSIZE, setting
* a fixed width overrides the automatically calculated width. Note that
- * @fixed_width is only a hint to GTK+; the width actually allocated to the
+ * @fixed_width is only a hint to GTK; the width actually allocated to the
* column may be greater or less than requested.
*
* Along with “expand”, the “fixed-width” property changes when the column is
* @minor: minor version (e.g. 2 for version 1.2.5)
* @micro: micro version (e.g. 5 for version 1.2.5)
*
- * Returns %TRUE if the version of the GTK+ header files
+ * Returns %TRUE if the version of the GTK header files
* is the same as or newer than the passed-in version.
*
- * Returns: %TRUE if GTK+ headers are new enough
+ * Returns: %TRUE if GTK headers are new enough
*/
#define GTK_CHECK_VERSION(major,minor,micro) \
(GTK_MAJOR_VERSION > (major) || \
* @Short_description: Base class for all widgets
* @Title: GtkWidget
*
- * GtkWidget is the base class all widgets in GTK+ derive from. It manages the
+ * GtkWidget is the base class all widgets in GTK derive from. It manages the
* widget lifecycle, states and style.
*
* # Height-for-width Geometry Management # {#geometry-management}
*
- * GTK+ uses a height-for-width (and width-for-height) geometry management
+ * GTK uses a height-for-width (and width-for-height) geometry management
* system. Height-for-width means that a widget can change how much
* vertical space it needs, depending on the amount of horizontal space
* that it is given (and similar for width-for-height). The most common
* example is a label that reflows to fill up the available width, wraps
* to fewer lines, and therefore needs less height.
*
- * Height-for-width geometry management is implemented in GTK+ by way
+ * Height-for-width geometry management is implemented in GTK by way
* of two virtual methods:
*
* - #GtkWidgetClass.get_request_mode()
* as well as its CSS style.
* If a widget used the wrappers inside its virtual method implementations,
* then the adjustments (such as widget margins) would be applied
- * twice. GTK+ therefore does not allow this and will warn if you try
+ * twice. GTK therefore does not allow this and will warn if you try
* to do it.
*
* Of course if you are getting the size request for
* Otherwise, you would not properly consider widget margins,
* #GtkSizeGroup, and so forth.
*
- * GTK+ also supports baseline vertical alignment of widgets. This
+ * GTK also supports baseline vertical alignment of widgets. This
* means that widgets are positioned such that the typographical baseline of
* widgets in the same row are aligned. This happens if a widget supports baselines,
* has a vertical alignment of %GTK_ALIGN_BASELINE, and is inside a widget
* Retrieves the name of a widget. See gtk_widget_set_name() for the
* significance of widget names.
*
- * Returns: name of the widget. This string is owned by GTK+ and
+ * Returns: name of the widget. This string is owned by GTK and
* should not be modified or freed
**/
const char *
*
* Returns the list of pointer #GdkDevices that are currently
* on top of @widget. Free the list
- * with g_free(), the elements are owned by GTK+ and must
+ * with g_free(), the elements are owned by GTK and must
* not be freed.
*/
GdkDevice **
* @to: the #GtkWidget the virtual pointer is moving to.
* @mode: the #GdkCrossingMode to place on the synthesized events.
*
- * Generate crossing event(s) on widget state (sensitivity) or GTK+ grab change.
+ * Generate crossing event(s) on widget state (sensitivity) or GTK grab change.
*/
void
_gtk_widget_synthesize_crossing (GtkWidget *from,
g_return_if_fail (resource_name && resource_name[0]);
/* This is a hack, because class initializers now access resources
- * and GIR/gtk-doc initializes classes without initializing GTK+,
+ * and GIR/gtk-doc initializes classes without initializing GTK,
* we ensure that our base resources are registered here and
* avoid warnings which building GIRs/documentation.
*/
*
* Whether mnemonics are currently visible in this window.
*
- * This property is maintained by GTK+ based on user input,
+ * This property is maintained by GTK based on user input,
* and should not be set by applications.
*/
window_props[PROP_MNEMONICS_VISIBLE] =
*
* Whether 'focus rectangles' are currently visible in this window.
*
- * This property is maintained by GTK+ based on user input
+ * This property is maintained by GTK based on user input
* and should not be set by applications.
*/
window_props[PROP_FOCUS_VISIBLE] =
* function before calling gtk_window_present() or any equivalent
* function generating a window map event.
*
- * This function is only useful on X11, not with other GTK+ targets.
+ * This function is only useful on X11, not with other GTK targets.
**/
void
gtk_window_set_startup_id (GtkWindow *window,
* [window managers][gtk-X11-arch] to e.g. keep the
* dialog on top of the main window, or center the dialog over the
* main window. gtk_dialog_new_with_buttons() and other convenience
- * functions in GTK+ will sometimes call
+ * functions in GTK will sometimes call
* gtk_window_set_transient_for() on your behalf.
*
* Passing %NULL for @parent unsets the current transient window.
* A typical widget used here is #GtkHeaderBar, as it provides various features
* expected of a titlebar while allowing the addition of child widgets to it.
*
- * If you set a custom titlebar, GTK+ will do its best to convince
+ * If you set a custom titlebar, GTK will do its best to convince
* the window manager not to put its own titlebar on the window.
* Depending on the system, this function may not work for a window
* that is already visible, so you set the titlebar before calling
*
* By default, windows are decorated with a title bar, resize
* controls, etc. Some [window managers][gtk-X11-arch]
- * allow GTK+ to disable these decorations, creating a
+ * allow GTK to disable these decorations, creating a
* borderless window. If you set the decorated property to %FALSE
- * using this function, GTK+ will do its best to convince the window
+ * using this function, GTK will do its best to convince the window
* manager not to decorate the window. Depending on the system, this
* function may not have any effect when called on a window that is
* already visible, so you should call it before calling gtk_widget_show().
* @setting: %TRUE to decorate the window as deletable
*
* By default, windows have a close button in the window frame. Some
- * [window managers][gtk-X11-arch] allow GTK+ to
+ * [window managers][gtk-X11-arch] allow GTK to
* disable this button. If you set the deletable property to %FALSE
- * using this function, GTK+ will do its best to convince the window
+ * using this function, GTK will do its best to convince the window
* manager not to show a close button. Depending on the system, this
* function may not have any effect when called on a window that is
* already visible, so you should call it before calling gtk_widget_show().
*
* Returns the fallback icon name for windows that has been set
* with gtk_window_set_default_icon_name(). The returned
- * string is owned by GTK+ and should not be modified. It
+ * string is owned by GTK and should not be modified. It
* is only valid until the next call to
* gtk_window_set_default_icon_name().
*
*
* Windows may not be resized smaller than 1 by 1 pixels.
*
- * When using client side decorations, GTK+ will do its best to adjust
+ * When using client side decorations, GTK will do its best to adjust
* the given size so that the resulting window size matches the
* requested size without the title bar, borders and shadows added for
* the client side decorations, but there is no guarantee that the
*
* Obtains the current size of @window.
*
- * If @window is not visible on screen, this function return the size GTK+
+ * If @window is not visible on screen, this function return the size GTK
* will suggest to the [window manager][gtk-X11-arch] for the initial window
* size (but this is not reliably the same as the size the window manager
* will actually select). See: gtk_window_set_default_size().
* Depending on the windowing system and the window manager constraints,
* the size returned by this function may not match the size set using
* gtk_window_resize(); additionally, since gtk_window_resize() may be
- * implemented as an asynchronous operation, GTK+ cannot guarantee in any
+ * implemented as an asynchronous operation, GTK cannot guarantee in any
* way that this code:
*
* |[<!-- language="C" -->
* or gtk_window_move().
*
* If the configure request has changed, we send off a new one. To
- * ensure GTK+ invariants are maintained (resize queue does what it
+ * ensure GTK invariants are maintained (resize queue does what it
* should), we go ahead and size_allocate the requested size in this
* function.
*
" <property name=\"label\">Long label</property>"
" <child>"
" <object class=\"GtkLabel\" id=\"label1\">"
- " <property name=\"label\" translatable=\"yes\">This is a really long label for the purpose of testing line wrapping is working correctly in conjunction with height-for-width support in GTK+</property>"
+ " <property name=\"label\" translatable=\"yes\">This is a really long label for the purpose of testing line wrapping is working correctly in conjunction with height-for-width support in GTK</property>"
" <property name=\"wrap\">True</property>"
" <property name=\"max_width_chars\">30</property>"
" <attributes>"
-/* testtooltips.c: Test application for GTK+ >= 2.12 tooltips code
+/* testtooltips.c: Test application for GTK >= 2.12 tooltips code
*
* Copyright (C) 2006-2007 Imendio AB
* Contact: Kristian Rietveld <kris@imendio.com>
int
main (int argc, char *argv[])
{
- /* Don't use gtk_test_init here because it implicitly initializes GTK+. */
+ /* Don't use gtk_test_init here because it implicitly initializes GTK. */
g_test_init (&argc, &argv, NULL);
gtk_disable_setlocale();
setlocale (LC_ALL, "C");
if (!g_type_is_a (type, G_TYPE_OBJECT))
return;
- /* non-GTK+ */
+ /* non-GTK */
if (g_str_equal (g_type_name (type), "GdkPixbufSimpleAnim"))
return;
if ((pspec->flags & G_PARAM_CONSTRUCT_ONLY) != 0)
continue;
- /* non-GTK+ */
+ /* non-GTK */
if (g_str_equal (g_type_name (pspec->owner_type), "GdkPixbufSimpleAnim") ||
g_str_equal (g_type_name (pspec->owner_type), "GMountOperation"))
continue;
/* Assert that the object finalizes properly */
g_object_weak_ref (object, check_finalized, &finalized);
- /* Toplevels are owned by GTK+, just tell GTK+ to destroy it */
+ /* Toplevels are owned by GTK, just tell GTK to destroy it */
if (GTK_IS_WINDOW (object))
gtk_window_destroy (GTK_WINDOW (object));
else
projects / gtk4.git / commitdiff